#include <stdio.h>
#include "fsio.h"
#include "matrice.h"


int charger (t_matrice* matrice,
			 t_clause** tab_clauses,
			 t_litteral** tab_variables,
			 char nom_fichier[]
			 )
{
	int nb_var;
	int nb_clauses;
	int courant;
	char buffer;
	int compteur_clauses = 1;
	
	FILE* fichier = fopen(nom_fichier, "r");
	
	if (!fichier) return -1;
	
	/* Lire le nombre de variables et de clauses */
	fscanf(fichier, "%d%d", &nb_var, &nb_clauses);

	init_matrice(matrice);
	*tab_clauses = init_clauses(nb_clauses);
	matrice->nb_clauses_a_traiter = nb_clauses;
	
	*tab_variables = init_variables(nb_var);

	while (fscanf(fichier, "%d", &courant) >= 0)
	{
		/**
		  * fscanf retourne -1 lorsqu'il ne reste plus aucun caractère
		  * à lire (fin du fichier).
		  **/
		  
		ajouter(matrice,
		        *tab_clauses,
		        *tab_variables,
		        compteur_clauses,
		        courant);

		/**
		  * "Manger" le caractère de séparation (,) ou
		  * le retour à la ligne. Le caractère de séparation
		  * n'est pas obligatoirement une virgule.
		  **/
		buffer = fgetc(fichier);
		
		if (buffer == '\n')
		{
			/**
			  * On a terminé la saisie d'une clause, 
			  * on passe à la suivante
			  **/
			compteur_clauses++;
		}
	}
		
	fclose(fichier);
	
	/* Ajuster la taille de la matrice à sa taille réelle. */
	reduire(matrice);
	
	return 1;
}


void afficher_tableau (t_matrice* matrice)
{
	for (int i=0; i < (matrice->nb_elements) ; i++)	
	{
		printf("%d\tClause : %d\tVariable : %d\tClause prec : %d\tClause suiv : %d\n",
			i,
			matrice->elements[i].num_clause,
			matrice->elements[i].num_variable,
			matrice->elements[i].ptr_clause_prec,
			matrice->elements[i].ptr_clause_suiv
			);
		
	}
}

void afficher_tab_clauses (t_clause* tab_clauses, int nb_clauses)
{
	for (int i=0; i < nb_clauses; i++)	
	{
		printf("Etat : %d\tPremier : %d\tDernier : %d\n",
			   tab_clauses[i].etat,
			   tab_clauses[i].ptr_premier,
			   tab_clauses[i].ptr_dernier
			   );
	}
}

void afficher_tab_variables (t_litteral* tab_variables, int nb_var)
{
	for (int i=1; i < nb_var+1; i++)	
	{
		switch(tab_variables[i].etat)
		{
			case NEUTRE: printf("\033[37m.\033[0m"); break;
			case VRAI: printf("\033[34m1\033[0m"); break;
			case FAUX: printf("\033[31m0\033[0m"); break;
		}
	}
	printf("\n");
}

void afficher_clauses (t_matrice* matrice, t_clause* tab_clauses)
{
	int num_variable;
	for (int i=1; i <= tab_clauses[0].ptr_premier; i++)
	{
		if (tab_clauses[i].etat != SATISFAITE)
		{

			switch (tab_clauses[i].etat)
			{
				case SATISFAITE: printf("SATISFAITE"); break;
				case INCHANGEE: printf("INCHANGEE"); break;
				case RACCOURCIE: printf("RACCOURCIE"); break;
			}
		
			printf(" (");
		
			t_ptr_elem courant = tab_clauses[i].ptr_premier;
		
			while (courant != NON_SIGNIFICATIF)
			{
				num_variable = matrice->elements[courant].num_variable;
			
				if (num_variable < 0)
				{
					num_variable = -num_variable; /* Valeur absolue */
					printf("\033[31m/x%d\033[0m ", num_variable);
				} else {
					printf("\033[34mx%d\033[0m ", num_variable);
				}

			
				courant = matrice->elements[courant].ptr_clause_suiv;
			}
			printf(")");
			printf (" Dernier : %d", matrice->elements[tab_clauses[i].ptr_dernier].num_variable);
			printf("\n");
		}
	}
}
